home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / source / scrasm / map.inc < prev    next >
Encoding:
Text File  |  1993-03-09  |  12.0 KB  |  413 lines
  1. ;; MAP in own segment allows map of tiles to be up to 65536 tiles in area
  2. ;; which translates to about 16.8 million pixels of virtual screen.  This
  3. ;; can be represented in almost any rectangle -- just set MAP_WIDTH.
  4.  
  5. ;; Sorry this code isn't commented -- I was working on it right up until
  6. ;; the point that I released this.  You have any questions?  Ask away
  7. ;; (my internet address is in the DOC file).
  8.  
  9. MAPHEADER       STRUCT, NONUNIQUE
  10.                 MapName BYTE    ""
  11.                 Wid     WORD    2
  12.                 Ht      WORD    3
  13.                 Extent  WORD    4
  14.                 OffX1   WORD    5
  15.                 OffY1   WORD    6
  16.                 OffX2   WORD    7
  17.                 OffY2   WORD    8
  18.                 WrapX   WORD    9
  19.                 WrapY   WORD    10
  20.                 Magic   WORD    11
  21. MAPHEADER       ENDS
  22. MapInfo         MAPHEADER <>
  23.  
  24.  
  25. ; In: DS:DX = offset of filename
  26. LoadMapFile     PROC    near
  27.                 mov     ax,segMap
  28.                 cmp     ax,-1
  29.                 je      map_not_loaded
  30.                 sub     ax,(SIZEOF MAPHEADER) / 16
  31.                 mov     es,ax
  32.                 mov     ah,49h
  33.                 int     21h
  34.                 mov     nError,ERR_MEM
  35.                 jc      lm_err
  36.                 mov     segMap,-1
  37.  
  38. map_not_loaded: call    LoadFile
  39.                 jc      lm_err
  40.  
  41.                 mov     ds,dx
  42.                 mov     si,0
  43.                 mov     ax,cs
  44.                 mov     es,ax
  45.                 lea     di,MapInfo
  46.                 mov     cx,(SIZEOF MAPHEADER) / 4
  47.             rep movsd
  48.  
  49.                 add     dx,(SIZEOF MAPHEADER) / 16
  50.                 mov     cs:segMap,dx
  51.  
  52.                 mov     BlankPage.Valid,0
  53.                 mov     ShowPage.Valid,0
  54.                 mov     DrawPage.Valid,0
  55.  
  56.                 mov     upper_left,0
  57.                 mov     ScrollPosX,0
  58.                 mov     ScrollPosY,0
  59.                 mov     ScrollDX,0
  60.                 mov     ScrollDY,0
  61.  
  62. lm_err:         ret
  63. LoadMapFile     ENDP
  64.  
  65. LoadTilesFile   PROC    near
  66.                 mov     ax,segTiles
  67.                 cmp     ax,-1
  68.                 je      tiles_not_loaded
  69.                 mov     es,ax
  70.                 mov     ah,49h
  71.                 int     21h
  72.                 mov     nError,ERR_MEM
  73.                 jc      lt_err
  74.                 mov     segMap,-1
  75.  
  76. tiles_not_loaded: call    LoadFile
  77.                 jc      lm_err
  78.                 mov     segTiles,dx
  79.  
  80.                 mov     BlankPage.Valid,0
  81.                 mov     ShowPage.Valid,0
  82.                 mov     DrawPage.Valid,0
  83.  
  84. lt_err:         ret
  85. LoadTilesFile   ENDP
  86.  
  87. EVEN
  88. LoadData        PROC    near
  89.         ; Load squares from data file
  90.                 mov     bx,nMap
  91.                 shl     bx,1
  92.                 mov     dx,fntblTiles[bx]
  93.                 mov     ds,segCode
  94.                 call    LoadTilesFile
  95.                 ; returns Carry if error
  96.                 jc      load_error
  97.  
  98.         ; Load map from data file
  99.                 mov     ds,segCode
  100.                 mov     bx,nMap
  101.                 shl     bx,1
  102.                 mov     dx,fntblMap[bx]
  103.                 call    LoadMapFile
  104.                 ; returns Carry if error
  105.  
  106. load_error:     ret
  107. LoadData        ENDP
  108.  
  109. EVEN
  110. update_full     PROC
  111.                 mov     ds,segTiles
  112.                 mov     es,segVideo
  113.                 mov     fs,segMap
  114.  
  115.                 mov     dx,SC_INDEX
  116.                 mov     al,MAP_MASK
  117.                 out     dx,al
  118.  
  119.                 mov     di,DrawPage.Address
  120.                 add     di,upper_left
  121.                 mov     bp,MapInfo.OffX1
  122.                 add     bp,MapInfo.OffY1
  123.  
  124.                 mov     dx,MapInfo.WrapX
  125.  
  126.                 mov     ch,(VIRTUAL_WIDTH/SQUARE_WIDTH)
  127. draw_full_loop: push    cx
  128.                 push    si
  129.                 push    dx
  130.  
  131.                 mov     al,11h
  132.                 mov     si,0
  133.  
  134. update_f_loop:  mov     dx,SC_INDEX + 1
  135.                 out     dx,al
  136.                 push    bp
  137.                 call    draw_col
  138.                 pop     bp
  139.                 sub     di,(VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4
  140.                 add     si,(SQUARE_WIDTH * SQUARE_HEIGHT) / 4
  141.                 shl     al,1
  142.                 jnc     update_f_loop
  143.  
  144.                 pop     dx
  145.                 dec     dx
  146.                 jnz     update_f_go_on
  147.                 mov     dx,MapInfo.Wid
  148.                 sub     bp,dx
  149. update_f_go_on: inc     bp
  150.                 pop     si
  151.                 add     di,(SQUARE_WIDTH/ 4)
  152.                 pop     cx
  153.                 dec     ch
  154.                 jnz     draw_full_loop
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.                 mov     dx,GC_INDEX
  167.                 mov     ax,ALL_COPY_BITS
  168.                 out     dx,ax
  169.  
  170.                 mov     dx,SC_INDEX
  171.                 mov     ax,0F02h
  172.                 out     dx,ax
  173.  
  174.                 mov     ds,segVideo
  175.                 mov     si,DrawPage.Address
  176.                 add     si,upper_left
  177.                 mov     es,segVideo
  178.                 mov     di,BlankPage.Address
  179.                 add     di,upper_left
  180.                 mov     cx,(VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4
  181.             rep movsb
  182.                 mov     si,DrawPage.Address
  183.                 add     si,upper_left
  184.                 mov     di,ShowPage.Address
  185.                 add     di,upper_left
  186.                 mov     cx,(VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4
  187.             rep movsb
  188.  
  189.                 mov     dx,GC_INDEX
  190.                 mov     ax,ALL_DRAW_BITS
  191.                 out     dx,ax
  192.  
  193.                 ret
  194. update_full     ENDP
  195.  
  196. EVEN
  197. update_left     PROC
  198.                 mov     ds,cs:segTiles
  199.                 mov     es,cs:segVideo
  200.                 mov     fs,cs:segMap
  201.  
  202.                 mov     dx,SC_INDEX
  203.                 mov     al,MAP_MASK
  204.                 out     dx,al
  205.  
  206.                 mov     al,011h
  207.                 mov     si,0
  208.                 mov     di,cs:DrawPage.Address
  209.                 add     di,cs:upper_left        ; becomes DI later
  210.                 mov     bp,MapInfo.OffX1
  211.                 add     bp,MapInfo.OffY1
  212.  
  213. update_l_loop:  mov     dx,SC_INDEX + 1
  214.                 out     dx,al
  215.                 push    bp
  216.                 call    draw_col
  217.                 pop     bp
  218.                 sub     di,(VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4
  219.                 add     si,(SQUARE_WIDTH * SQUARE_HEIGHT) / 4
  220.                 shl     al,1
  221.                 jnc     update_l_loop
  222.  
  223.                 ret
  224. update_left     ENDP
  225.  
  226. EVEN
  227. update_right    PROC    near
  228.                 mov     ds,cs:segTiles
  229.                 mov     es,cs:segVideo
  230.                 mov     fs,cs:segMap
  231.  
  232.                 mov     dx,SC_INDEX
  233.                 mov     al,MAP_MASK
  234.                 out     dx,al
  235.  
  236.                 mov     bp,MapInfo.OffX2
  237.                 add     bp,MapInfo.OffY1
  238.  
  239.                 mov     al,011h
  240.                 mov     si,0
  241.  
  242.                 mov     di,cs:DrawPage.Address  ; becomes DI
  243.                 add     di,cs:upper_left
  244.                 add     di,(VIRTUAL_WIDTH - SQUARE_WIDTH) / 4
  245.  
  246. update_r_loop:  mov     dx,SC_INDEX + 1
  247.                 out     dx,al
  248.  
  249.                 push    bp
  250.                 call    draw_col
  251.                 pop     bp
  252.                 sub     di,(VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4
  253.                 add     si,(SQUARE_WIDTH * SQUARE_HEIGHT) / 4
  254.                 shl     al,1
  255.                 jnc     update_r_loop
  256.  
  257.                 ret
  258. update_right    ENDP
  259.  
  260. EVEN
  261. update_top      PROC
  262.                 mov     ds,cs:segTiles
  263.                 mov     es,cs:segVideo
  264.                 mov     fs,cs:segMap
  265.  
  266.                 mov     dx,SC_INDEX
  267.                 mov     al,MAP_MASK
  268.                 out     dx,al
  269.  
  270.                 mov     di,cs:DrawPage.Address
  271.                 add     di,cs:upper_left
  272.                 mov     bp,MapInfo.OffX1
  273.                 add     bp,MapInfo.OffY1
  274.  
  275.                 mov     al,011h
  276.                 mov     si,0
  277.  
  278. update_top_loop:
  279.                 mov     dx,SC_INDEX + 1
  280.                 out     dx,al
  281.                 push    bp
  282.                 call    draw_row
  283.                 pop     bp
  284.                 sub     di,VIRTUAL_WIDTH / 4
  285.                 add     si,(SQUARE_WIDTH * SQUARE_HEIGHT) / 4
  286.                 shl     al,1
  287.                 jnc     update_top_loop
  288.  
  289.                 ret
  290. update_top      ENDP
  291.  
  292. EVEN
  293. update_bottom   PROC
  294.                 mov     ds,cs:segTiles
  295.                 mov     es,cs:segVideo
  296.                 mov     fs,cs:segMap
  297.  
  298.                 mov     dx,SC_INDEX
  299.                 mov     al,MAP_MASK
  300.                 out     dx,al
  301.  
  302.                 mov     di,cs:DrawPage.Address
  303.                 add     di,cs:upper_left
  304.                 add     di,(VIRTUAL_WIDTH * (VIRTUAL_HEIGHT - SQUARE_HEIGHT)) / 4
  305.                 mov     bp,MapInfo.OffX1
  306.                 add     bp,MapInfo.OffY2
  307.  
  308.                 mov     al,011h
  309.                 mov     si,0
  310.  
  311. update_bottom_loop:
  312.                 mov     dx,SC_INDEX + 1
  313.                 out     dx,al
  314.                 push    bp
  315.                 call    draw_row
  316.                 pop     bp
  317.                 sub     di,VIRTUAL_WIDTH / 4
  318.                 add     si,(SQUARE_WIDTH * SQUARE_HEIGHT) / 4
  319.                 shl     al,1
  320.                 jnc     update_bottom_loop
  321.  
  322.                 ret
  323. update_bottom   ENDP
  324.  
  325. ; Draws ONE plane of a single col
  326. EVEN
  327. draw_col        PROC    near
  328.         ; DI->upper left corner of col to draw
  329.         ; BP->col of map to draw
  330.         ; SI used to point at tiles
  331.         ; AX,CX used
  332.         ; BX used to push SI
  333.         ; DX unused
  334.                 shl     eax,16  ; save it
  335.                 mov     ax,MapInfo.WrapY
  336.  
  337.                 mov     cl,(VIRTUAL_HEIGHT / SQUARE_HEIGHT)
  338. do_col_loop:    mov     bx,si
  339.                 mov     bh,byte ptr fs:[bp]     ; change tile #
  340.  
  341.                 mov     ch,SQUARE_HEIGHT
  342. do_col_sq_loop: mov     dl,byte ptr ds:[bx+2]
  343.                 mov     dh,byte ptr ds:[bx+3]
  344.                 shl     edx,16
  345.                 mov     dl,byte ptr ds:[bx+0]
  346.                 mov     dh,byte ptr ds:[bx+1]
  347.                 mov     es:[di],edx     ; 32-bit write
  348.                 add     di,VIRTUAL_WIDTH / 4
  349.                 add     bx,4
  350.                 dec     ch
  351.                 jnz     do_col_sq_loop
  352.  
  353.                 add     bp,MapInfo.Wid
  354.                 dec     ax
  355.                 jnz     yayaya
  356.                 mov     ax,MapInfo.Ht
  357.                 sub     bp,MapInfo.Extent
  358. yayaya:
  359.  
  360.                 dec     cl
  361.                 jnz     do_col_loop
  362.  
  363.                 shr     eax,16  ; restore it
  364.  
  365.                 ret
  366. draw_col        ENDP
  367.  
  368. ; Draws ONE plane of a single row
  369. EVEN
  370. draw_row        PROC    near
  371.                 push    ax
  372. ;               shl     eax,16  ; save ax
  373.  
  374.                 mov     ax,MapInfo.WrapX
  375.  
  376.         ; DI->upper left corner of row to draw
  377.         ; BP->row of map to draw
  378.         ; SI used to point at tiles
  379.         ; AX,CX used
  380.         ; BX used to push SI
  381.         ; DX unused
  382.  
  383.                 mov     cl,(VIRTUAL_WIDTH / SQUARE_WIDTH)
  384. do_row_loop:    mov     bx,si
  385.                 mov     bh,byte ptr fs:[bp]     ; change tile #
  386.  
  387.                 mov     ch,SQUARE_HEIGHT
  388. do_row_sq_loop: mov     dl,byte ptr ds:[bx+2]
  389.                 mov     dh,byte ptr ds:[bx+3]
  390.                 shl     edx,16
  391.                 mov     dl,byte ptr ds:[bx+0]
  392.                 mov     dh,byte ptr ds:[bx+1]
  393.                 mov     es:[di],edx
  394.                 add     di,(VIRTUAL_WIDTH / 4)
  395.                 add     bx,4
  396.                 dec     ch
  397.                 jnz     do_row_sq_loop
  398.  
  399.                 add     di,(-VIRTUAL_WIDTH*SQUARE_HEIGHT + SQUARE_WIDTH) / 4
  400.                 inc     bp
  401.                 dec     ax
  402.                 jnz     yayaya2
  403.                 mov     ax,MapInfo.Wid
  404.                 sub     bp,ax
  405. yayaya2:
  406.                 dec     cl
  407.                 jnz     do_row_loop
  408.  
  409. ;               shr     eax,16  ; restore it
  410.                 pop     ax
  411.                 ret
  412. draw_row        ENDP
  413.